LeetCode 分类练习 Task01：分治

笔记

1. 分治算法的主要思想是将原问题递归地分成若干个子问题，直到子问题满足边界条件，停止递归。将子问题逐个击破，将已经解决的子问题合并，最后，算法会层层合并得到原问题的答案。

2. 分治法适用的情况

（1）原问题的计算复杂度随着问题的规模的增加而增加。

（2）原问题能够被分解成更小的子问题。

（3）子问题的结构和性质与原问题一样，并且相互独立，子问题之间不包含公共的子子问题。

（4） 原问题分解出的子问题的解可以合并为该问题的解。

3. 归并排序算法: 就是将两个有序的小数组，合并成一个有序的数组。实际上，在这个合并的过程中，可以计算这两个小数组的逆序对个数了。每次合并操作，我们都计算逆序对个数，把这些计算出来的逆序对个数求和，就是这个数组的逆序对个数了。

练习

class Solution(object):
    def majorityElement2(self, nums):
    # 不断切分的终止条件
        if not nums:
            return None
        if len(nums) == 1:
            return nums[0]
    #准备数据，并将大问题拆分为小问题
        left = self.majorityElement(nums[:len(nums)//2])
        right = self.majorityElement(nums[len(nums)//2:])
    # 处理子问题，得到子结果
    # 对子结果进行合并 得到最终结果
        if left == right:
            return left
        if nums.count(left) > nums.count(right):
            return left
        else:
            return right 

class Solution(object):
    def maxSubArray(self, nums):
        # 确定不断切分的终止条件
        n = len(nums)
        if n == 1:
            return nums[0]
        # 准备数据，并将大问题拆分为小的问题
        left = self.maxSubArray(nums[:len(nums)//2])
        right = self.maxSubArray(nums[len(nums)//2:])
        # 处理小问题，得到子结果
        # 从右到左计算左边的最大子序和
        max_l = nums[len(nums)//2 -1] # max_l为该数组的最右边的元素
        tmp = 0 # tmp用来记录连续子数组的和
        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(left,right,max_l+ max_r)

class Solution(object):
    def myPow(self, x, n):
        # 处理n为负的情况
        if n < 0 :
            x = 1/x
            n = -n
        # 确定不断切分的终止条件
        if n == 0 :
            return 1
        # 准备数据，并将大问题拆分为小的问题
        if n%2 ==1:
        # 处理小问题，得到子结果
            p = x * self.myPow(x,n-1)# 对子结果进行合并 得到最终结果
            return p
        return self.myPow(x*x,n/2)