分治

分治算法

主要思想

分治算法的主要思想是将原问题递归地分成若干个子问题，直到子问题满足边界条件，停止递归。把一个复杂的问题分成多个相同或相似的子问题，再把子问题分成更小的子问题直到最后子问题可以简单地直接求解，原问题的解即子问题的解的合并。

分治算法的步骤

• 分：递归地将问题分解为各个的子问题(性质相同的、相互独立的子问题)
• 治：将这些规模更小的子问题逐个击破
• 合：将已解决的子问题逐层合并，最终得出原问题的解
  

分治法适用的情况

1. 原问题的计算复杂度随着问题的规模的增加而增加
2. 原问题能够被分解成更小的子问题
3. 子问题的结构和性质与原问题一样，并且相互独立，子问题之间不包含公共的子子问题
4. 原问题分解出的子问题的解可以合并为该问题的解

• 第一条特征绝大多数问题都可以满足，因为问题的计算复杂度一般是随着问题规模的增加而增加。
• 第二条特征是应用分治法的前提，反映了递归思想的应用，绝大多数问题也可以满足。
• 第三条特征涉及到了分治法的效率，如果各子问题是不独立的则分治法要做许多不必要的工作，重复地求解公共子问题。此时虽然可用分治法，但一般用动态规划法较好。
• 第四条特征是关键，能否利用分治法完全取决于问题是否具有第四条特征。如果一个问题具备了第一条和第二条特征，而不具备第三条特征，则可以考虑用贪心法或动态规划法。

伪代码

def divide_conquer(problem, paraml, param2,...):
    # 终止条件(子问题的边界条件)
    if problem is None:
        print_result
        return
    # 准备数据
    data=prepare_data(problem)
    # 将大问题拆分为小问题
    subproblems=split_problem(problem, data)
    # 处理小问题，得到子结果
    subresult1=self.divide_conquer(subproblems[0],p1,..)
    subresult2=self.divide_conquer(subproblems[1],p1,...)
    subresult3=self.divide_conquer(subproblems[2],p1,...)
    # 对子结果进行合并 得到最终结果
    result=process_result(subresult1, subresult2, subresult3,...)

举例说明

求出一组数据的有序对个数或者逆序对个数

假设有 $n$ 个数据，期望数据从小到大排列，那么完全有序的数据（$n$个数严格从小到大排列）的有序度就是 $n(n-1)/2$，逆序度等于 0；相反，倒序排列的数据（$n$个数严格从大到小排列）的有序度就是 0，逆序度是 $n(n-1)/2$。

因为有序对个数和逆序对个数的求解方式是类似的，所以这里可以只思考逆序对（常接触的）个数的求解方法。

• 方法1

  • 对于数组中的每一个数，统计这个数后面比它小的数的个数，记为 $k$
  • 把每个数字对应的 $k$ 值求和，得到的总和就是逆序对个数
  • 这样操作的时间复杂度是$O(n^2)$（${\sum }_{i=1}^{n}n-i$）

• 方法2

• 将数组分成前后两半，记为 $A1$ 和 $A2$

• 分别计算 $A1$ 和 $A2$ 的逆序对个数 $K1$ 和 $K2$

• 然后再计算 $A1$ 与 $A2$ 之间的逆序对个数 $K3$

• 数组 $A$ 的逆序对个数就等于 $K1+K2+K3$

  注意使用分治算法其中一个要求是，子问题合并的代价不能太大，否则就起不了降低时间复杂度的效果了。

  如何快速计算出两个子问题 $A1$ 与 $A2$ 之间的逆序对个数呢？这里使用的是归并排序算法。归并排序中有一个非常关键的操作，就是将两个有序的小数组，合并成一个有序的数组，在合并的过程中，计算两个小数组的逆序对个数。每次合并操作，都计算逆序对个数，把这些计算出来的逆序对个数求和，就是这个数组的逆序对个数了。

算法应用

多数元素

题目描述：

给定一个大小为 n 的数组，找到其中的众数。众数是指在数组中出现次数大于 [n/2] 的元素。
你可以假设数组是非空的，并且给定的数组总是存在众数。

示例 1:
输入: [3,2,3]
输出: 3

示例 2:
输入: [2,2,1,1,1,2,2]
输出: 2

解题思路：

• 确定切分的终止条件
  直到所有的子问题都是长度为 1 的数组，停止切分
• 准备数据，将大问题切分为小问题
  递归地将原数组二分为左区间与右区间，直到最终的数组只剩下一个元素，返回该元素
• 处理子问题得到子结果，并合并子结果
  • 长度为 1 的子数组中唯一的数显然是众数，直接返回即可
  • 如果左右区间的众数相同，那么显然该众数就是这一区间的众数
  • 如果左右区间的众数不同，比较两个众数在整个区间内出现的次数来决定该区间的众数

代码：

class Solution:
    def majorityElement(self, nums: List[int]) -> int:
        # 终止条件
        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
        else:
            if nums.count(left) > nums.count(right):
                return left
            else:
                return right

优化解法：

采用投票法，用变量 maj 记录多数元素，count 用来计数，遍历 nums 数组，如果遇到和当前 maj 相同的元素则 count 加 1，否则 count 减 1，当 count 减至 0 时，替换 maj 为当前遍历的数。最后得到的 maj 即为该数组的众数。

该方法只对数组进行了一次遍历，时间复杂度为 $O(n)$。空间复杂度为 $O(1)$ ，只需要常数级别的额外空间。

因为题目中众数的定义是出现的次数 $>[n/2]$ 的数，因此保证了投票法是可行的，无论数组的排列顺序是怎样的，众数的出现次数总是大于其他数出现的次数之和。

代码：

class Solution:
    def majorityElement(self, nums: List[int]) -> int:
        maj = nums[0]
        count = 1
        for i in range(1,len(nums)):
            if maj == nums[i]:
                count += 1
            else:
                count -= 1
                if count == 0:
                    maj = nums[i]
                    count = 1
        return maj

最大子序和

题目描述：

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

示例:
输入: [-2,1,-3,4,-1,2,1,-5,4]
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大为6

解题思路:

• 确定切分的终止条件
  直到所有的子问题都是长度为 1 的数组，停止切分
• 准备数据，将大问题切分为小问题
  递归地将原数组二分为左区间与右区间，直到最终的数组只剩下一个元素，将其返回
• 处理子问题得到子结果，并合并子结果
  • 将数组切分为左右区间
  • 对与左区间：从右到左计算左边的最大子序和 $|\leftarrow$
  • 对与右区间：从左到右计算右边的最大子序和 $\to |$
  • 由于左右区间计算累加和的方向不一致，因此，左右区间直接合并相加之后就是整个区间的和 $|\leftarrow \to |$
  • 最终返回左区间的元素、右区间的元素、以及整个区间(相对子问题)和的最大值

代码：

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        # 确定终止条件
        if not nums:
            return None
        if len(nums) == 1:
            return nums[0]
        # 拆分问题
        left = self.maxSubArray(nums[:len(nums)//2])
        right = self.maxSubArray(nums[len(nums)//2:])
        # 解决子问题
        # 右到左计算左边的最大子序和
        temp = 0
        max_l =nums[len(nums)//2-1] # 最右边的元素
        for i in range(len(nums)//2-1,-1,-1):
            temp += nums[i]
            max_l = max(max_l,temp)
        
        temp = 0
        max_r = nums[len(nums)//2] # 最左边的元素
        for i in range(len(nums)//2,len(nums)):
            temp += nums[i]
            max_r = max(max_r,temp)
        # 合并结果
        return max(left,right,max_l+max_r)

Pow(m,n)

题目描述：

实现 $pow(x,n)$ ，即计算 $x$ 的 $n$ 次幂函数。

示例 1:
输入: 2.00000, 10
输出: 1024.00000

示例 2:
输入: 2.10000, 3
输出: 9.26100

示例 3:
输入: 2.00000, -2
输出: 0.25000

说明:
$-100.0<x<100.0$ ，$n$ 是 $32$ 位有符号整数，其数值范围是$[-2^{31},2^{31}-1]$.

解题思路：

• 确定切分的终止条件（不妨假设$n\ge 0$，$n<0$时可以把$pow(x,n)$视为$pow(1/x,-n)$）
  若 $n$ 能整除 $2$ 则更新 $n$ 为 $n/2$，否则更新 $n$ 为 $n-1$，直到 $n=0$
• 准备数据，将大问题切分为小问题
  若 $n$ 能整除 $2$ 则更新 $n$ 为 $n/2$，否则更新 $n$ 为 $n-1$
• 处理子问题得到子结果，并合并子结果
  • 如果 $n\%2=1$
    返回 $x\ast pow(x,n-1)$
  • 如果$n\%2=0$
    返回 $pow(x\ast x,n/2)$

代码：

class Solution:
    def myPow(self, x: float, n: int) -> float:
        # 终止条件
        if n == 0:
            return 1
        # 处理n<0的情形
        if n < 0:
            n = -n
            x = 1/x
        # 准备数据，将大问题切分为小问题
        if n%2 == 1: # 处理子问题并合并结果
            return x*self.myPow(x,n-1)
        else:
            return self.myPow(x*x,n/2)