leetcode刷题记录：算法（五）分治法

分治法（Divide&Conquer）

• 将一个大问题分解为一个个的小问题，然后将小问题解决后再将结果整合以后，就能得到大问题的解
• 用到了递归

直接看题吧：
53.最大子序和
给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

题目的难度是简单，突然自卑。想了半天写了个O(n)复杂度的，而且并没有想到分治应该怎么写，用了滑动窗口，先记录一下吧：

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        left, right = 0, -1
        sum_sub = 0
        max_sum = nums[0]
        ## 右窗口移动n次，遍历整个序列
        for i in range(len(nums)):
            right += 1
            ## sum_sub是当前窗口子集和
            sum_sub += nums[right]
            ## 如果子集和小于0，那么这个子集对于后面的子集来说，只有副作用，所以要抛弃
            ## 经过这一步，子集和应该为正，或者子集中只有一个元素（left=right）
            while(sum_sub<0 and left<right):
                sum_sub -= nums[left]
                left+=1     
            ## 子集为正，但是有可能左窗口还为负值，起反作用，所以也要丢掉
            while(nums[left]<0 and left<right):
                sum_sub -= nums[left]
                left+=1
            ## 当前子集和与历史子集和对比，取最大             
            max_sum = max(max_sum, sum_sub)
        return max_sum           

执行用时：32 ms, 在所有 Python3 提交中击败了99.84%的用户
内存消耗：13.9 MB, 在所有 Python3 提交中击败了82.54%的用户

想了半天，灰溜溜的滚去看讲解了，根据讲解来写分治算法：
对于一个数组nums，其长度为high-low，中间值为mid，他的最大子序，有三种可能：

1. 在low和mid之间；
2. 再mid和high之间；
3. 跨过了mid，两边都有涉猎。

不断划分下去，最后切成单独的元素后，开始逐步返回上层。
最后的返回值为三者中的最大值。

class Solution:
    def maxSubArray(self, nums: List[int]) -> 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)

这是直接复制了评论区的代码，不过跑起来速度比较慢。

169.多数元素

class Solution:
    def majorityElement(self, nums: List[int]) -> int:
        # 分治思想：存在数组n, n的多数元素为a, 对于对n均分的左子集left和右子集right
        # a至少为其中一个子集的多数元素。
        # 反过来思考：
        # 如果两边的多数元素相同，那么这个元素就是整个数组的多数元素
        # 如果两边的多数元素不同，那么就要对比这两个结果，要找到整个数组的多数元素
        def majorityelement_findLR(left,right):
            if left == right:
                return nums[left]
            mid = (right + left) // 2
            left_max = majorityelement_findLR(left, mid)
            right_max = majorityelement_findLR(mid+1, right)
            if left_max == right_max:
                return left_max
            left_count = sum(1 for i in range(left, right+1) if nums[i] == left_max)
            right_count = sum(1 for i in range(left, right+1) if nums[i] == right_max)
            return left_max if left_count>right_count else right_max
        return majorityelement_findLR(0,len(nums)-1)

215. 数组中的第K个最大元素
     最直接的思路是归并排序，但是显然不应该用这么简单的方法。

class Solution:
    def findKthLargest(self, nums: List[int], k: int) -> int:
        def partition(left, right):
            pivot = nums[left]
            l = left + 1
            r = right
            while l <= r:
                if nums[l] < pivot and nums[r] > pivot:
                    nums[l], nums[r] = nums[r], nums[l]
                if nums[l] >= pivot:
                    l += 1
                if nums[r] <= pivot:
                    r -= 1
            nums[r], nums[left] = nums[left], nums[r]
            return r
        left = 0
        right = len(nums) - 1
        while 1:
            idx = partition(left, right)
            if idx == k - 1:
                return nums[idx]
            if idx < k - 1:
                left = idx + 1
            if idx > k - 1:
                right = idx - 1