leetcode刷题（9-代码敲不队-QQ）8.18

50. Pow(x, n)，求x的n次方

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

51. 最大子序和
    给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
    分治法：

class Solution:
    def maxSubArray(self, nums: list) -> int:
        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)
a=Solution();
print(a.maxSubArray([-2,1,-3]))

动态规划法：

class Solution:
    def maxSubArray(self, nums: list) -> int:
        n=len(nums)

        for i in range(1,n):
            if nums[i-1]>0:
                nums[i]+=nums[i-1]

        return max(nums)
a=Solution()
print(a.maxSubArray([-2,1,-3,4,-1,2,1,-5,4]))

贪心法：

class Solution:
    def maxSubArray(self, nums: list) -> int:
        if not nums:
            return -2147483648
        cur_sum = max_sum=nums[0]

        for i in range(1,len(nums)):
            cur_sum=max(cur_sum+nums[i],nums[i])
            max_sum=max(max_sum,cur_sum)
        return max_sum
a=Solution()
print(a.maxSubArray([-2,1,-3,4,-1,2,1,-5,4]))

169. 多数元素
     给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素
     方法一：

class Solution(object):
    def majorityElement(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        b=set(nums)
        for i in b:
            n=0
            for j in nums:
                if j == i:
                    n+=1
            if n>len(nums)//2:
                return i
a=Solution()
print(a.majorityElement([2,3,2,2,1,2,2,3,3,3,3,3,3,3,3]))

方法二，哈希到字典中

from collections import Counter
class Solution:
    def majorityElement(self, nums):
        counts = Counter(nums)
        return max(counts.keys(), key=counts.get)
a=Solution()
print(a.majorityElement([2,2,3]))

方法三、排序

class Solution:
    def majorityElement(self, nums):
        nums.sort()
        return nums[len(nums)//2]
a=Solution()
print(a.majorityElement([2,3,2,2,1,2,2,3]))

对于这种算法，我们先将 nums 数组排序，然后返回上文所说的下标对应的元素。

class Solution:
    def majorityElement(self, nums, lo=0, hi=None):
        def majority_element_rec(lo, hi):
            # base case; the only element in an array of size 1 is the majority
            # element.
            if lo == hi:
                return nums[lo]

            # recurse on left and right halves of this slice.
            mid = (hi-lo)//2 + lo
            left = majority_element_rec(lo, mid)
            right = majority_element_rec(mid+1, hi)

            # if the two halves agree on the majority element, return it.
            if left == right:
                return left

            # otherwise, count each element and return the "winner".
            left_count = sum(1 for i in range(lo, hi+1) if nums[i] == left)
            right_count = sum(1 for i in range(lo, hi+1) if nums[i] == right)

            return left if left_count > right_count else right

        return majority_element_rec(0, len(nums)-1)
a=Solution()
print(a.majorityElement([1,2,3,5,6,2]))