Datawhale编程实践LeetCode分类练习——Task01：分治（Python）

目录
1、50. Pow(x, n)
2、53. 最大子序和
3、169. 多数元素

50. Pow(x, n)（中等）

方法一（超时）：
通过循环将n个x乘起来，时间复杂度为O(n)

方法二：快速幂法（分治思想）
注意：

• n==0的情况
• n<0的情况

class Solution:
    def myPow(self, x: float, n: int) -> float:
        if n==1:
            return x
        if n==0:
            return 1
        
        if n>0:
            return self.helper(x,n)
        return 1/self.helper(x,-n)

    def helper(self,x,n):
        if n==1:
            return x
        num = self.helper(x,n//2)
        if n%2==0:            
            return num*num
        return num*num*x

复杂度分析：
时间复杂度O(logn) ： 二分的时间复杂度为对数级别。
空间复杂度 O(1)： 其余变量占用常数大小额外空间，递归需要O(logn)的额外栈空间。

53. 最大子序和（简单）

方法一：动态规划
思路：
dp[i]表示nums[0]到nums[i]中连续子数组的最大和

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        if not nums:
            return 0
        
        dp = [0 for _ in range(len(nums))]
        dp[0] = nums[0]
        
        res = dp[0]
        for i in range(1,len(nums)):
            if dp[i-1]<0:
                dp[i] = nums[i]
            else:
                dp[i] = dp[i-1]+nums[i]
            res = max(res,dp[i])
        return res

复杂度分析：
时间复杂度O(n) ： 数组中的元素都遍历一遍。
空间复杂度 O(n)： 额外的dp数组。

方法二：动态规划优化
dp[i]的计算只与dp[i-1]有关

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        if not nums:
            return 0
        
        last = nums[0]        
        res = last
        for i in range(1,len(nums)):
            last = max(nums[i]+last,nums[i])
            res = max(res,last)
        return res

复杂度分析：
时间复杂度O(n) ： 数组中的元素都遍历一遍。
空间复杂度 O(1)： 常数。

进阶问题
方法三：分治法
分类讨论：

1. 在左子区间[left,mid]
2. 在右子区间[mid+1,right]
3. 横跨两个区间，nums[mid]和nums[mid+1]一定会被选取（从中间向两边扩散）
   取三者max即可

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        n = len(nums)
        if n==0:
            return 0
        return self._maxsubarray(nums,0,n-1)
    
    def _maxsubarray(self,nums,lo,hi):
        if lo==hi:
            return nums[lo]
        
        mid = (hi-lo)//2 + lo
        return max(self._maxsubarray(nums,lo,mid),
                   self._maxsubarray(nums,mid+1,hi),
                   self._maxcrossarray(nums,lo,mid,hi))
    
    def _maxcrossarray(self,nums,lo,mid,hi):
        left_sum = 0
        left = mid-1
        s1 = 0
        while left>=lo:
            s1 += nums[left]
            left_sum = max(left_sum,s1)
            left -= 1
        
        right_sum = 0
        right = mid+1
        s2 = 0
        while right<=hi:
            s2 += nums[right]
            right_sum = max(right_sum,s2)
            right += 1
        
        return left_sum+nums[mid]+right_sum

复杂度分析：
时间复杂度O(nlogn) ： 递归的深度是对数级别的，每一层遍历一遍lo到hi。
空间复杂度 O(logn)： 递归需要额外的栈空间。

参考

169. 多数元素（简单）

方法一：哈希表
字典，记录数组中元素出现的次数

class Solution:
    def majorityElement(self, nums: List[int]) -> int:
        if len(nums)==1:
            return nums[0]
        dic = {}
        ans = len(nums)//2
        for num in nums:
            if num in dic:
                dic[num] += 1
                if dic[num]>ans:
                    return num
            else:
                dic[num] = 1
        return 

复杂度分析：
时间复杂度O(n) ： 最差的情况就是把数组中的元素都遍历一遍，插入哈希表只需要常数时间。
空间复杂度O(n)： 因为众数一定存在，众数最少会占用 n//2+1 个数字，最多有 n-(n//2+1) 个其他元素，因此哈希表最多包含 n-n//2个键值对，占用的空间为O(n)。

方法二：排序
排序后，数组下标为 n//2 的元素一定是众数

class Solution:
    def majorityElement(self, nums):
        nums.sort()
        return nums[len(nums)//2]

复杂度分析：
时间复杂度O(nlogn) ： 排序需要O(nlogn)的时间复杂度。
空间复杂度O(logn)：语言自带的排序算法算法需要O(logn)的栈空间。

方法三：分治
思路
如果a是数组nums的众数，将数组分为左右两个部分，a必定至少是一个部分的众数。
递归求解：

1. 递归求解。长度为1的数组，直接返回唯一的元素。
2. 长度大于1，如果左右子区间的众数相同，则就是该区间的众数；否则，比较两个元素在整个区间中出现的次数。

class Solution:
    def majorityElement(self, nums: List[int]) -> int:
        if len(nums)==1:
            return nums[0]
        def helper(lo,hi):
            if lo==hi:
                return nums[lo]
            
            mid = (hi-lo)//2+lo
            left = helper(lo,mid)
            right = helper(mid+1,hi)

            if left==right:
                return left
            
            left_count = 0
            right_count = 0
            for i in range(lo,hi+1):
                if nums[i]==left:
                    left_count += 1
                elif nums[i]==right:
                    right_count += 1
            
            if left_count>right_count:
                return left
            return right
        
        return helper(0,len(nums)-1)

复杂度分析：
时间复杂度O(nlogn) ： helper()里需要进行两次长度为n的线性扫描。
空间复杂度O(logn)：递归需要额外的栈空间，此处需要进行O(logn)次递归。

参考官方题解