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)次递归。

参考官方题解

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值