分治算法：LeetCode经典题目，使用Python

分治算法

  MapReduce（分治算法的应用） 是 Google 大数据处理的三驾马车之一，另外两个是 GFS 和 Bigtable。它在倒排索引、PageRank 计算、网页分析等搜索引擎相关的技术中都有大量的应用。尽管开发一个 MapReduce 看起来很高深，感觉遥不可及。实际上，万变不离其宗，它的本质就是分治算法思想，分治算法。

主要思想

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

分治算法的步骤

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

分治法适用的情况

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,...)

算法应用

剑指51.数组中的逆序对【困难】

---

有序度：表示一组数据的有序程度；
逆序度：表示一组数据的无序程度。

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

一般通过计算有序对或者逆序对的个数，来表示数据的有序度或逆序度。

---

LeetCode传送门
在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组，求出这个数组中的逆序对的总数。0 <= 数组长度 <= 50000

示例 ：

• 输入: [7,5,6,4]
• 输出: 5

思路1： 暴力

• 拿数组里的每个数字跟它后面的数字比较，看有几个比它小的。
• 把比它小的数字个数记作 k ，通过这样的方式，把每个数字都考察一遍之后，然后对每个数字对应的 k
  值求和。
• 最后得到的总和就是逆序对个数。
• 这样操作的时间复杂度是$O(n^2)$（需要两层循环过滤）。

思路2： 分治

• 首先将数组分成前后两半 A1 和 A2，分别计算 A1 和 A2 的逆序对个数 K1 和 K2；
• 然后再计算 A1 与 A2 之间的逆序对个数 K3。那数组 A 的逆序对个数就等于 K1+K2+K3。
• 如何快速计算出两个子问题A1与A2之间的逆序对个数呢？这里就要借助归并排序算法了。归并排序中有一个非常关键的操作，就是将两个有序的小数组，合并成一个有序的数组。实际上，在这个合并的过程中，可以计算这两个小数组的逆序对个数了。每次合并操作，我们都计算逆序对个数，把这些计算出来的逆序对个数求和，就是这个数组的逆序对个数了。

如何在归并排序的合并过程中记录逆序数： 假设现要合并 $L$ 和 $R$ 两个有序数组，

• 新建数组 $M$ 用于存放合并后的数组，在合并过程中有两个指针 $lPtr$ 、$rPtr$ 分别指向 $L$ 和 $R$ 当前待合并的数；
• 当前 $lPtr$ 指向的数字比 $rPtr$ 指向的数字小，但比 $R$ 中 $[0,1,...,rPtr-1]$ 的数字大，$R$ 中 $[0,1,...,rPtr-1]$ 的数字本应在$lPtr$ 指向的数字的左边，但是它排在了右边（$L$ 在 $R$左边），所以就贡献了 $rPtr$ 个逆序对。
• 同理，倘若当前 $rPtr$ 指向的数字比 $lPtr$ 指向的数字小，$L$中位置$[lPtr:]$与 $rPtr$所指数字构成逆序对，此时不需要计数，否则与上一情况重复计数。

代码：

class Solution:
    def mergeSort(self, nums, tmp, l, r):
        if l >= r:
            return 0

        mid = (l + r) // 2
        inv_count = self.mergeSort(nums, tmp, l, mid) + self.mergeSort(nums, tmp, mid + 1, r)
        i, j, pos = l, mid + 1, l
        while i <= mid and j <= r:
            if nums[i] <= nums[j]:
                tmp[pos] = nums[i]
                i += 1
                inv_count += (j - (mid + 1))
            else:
                tmp[pos] = nums[j]
                j += 1
            pos += 1
        for k in range(i, mid + 1):
            tmp[pos] = nums[k]
            inv_count += (j - (mid + 1))
            pos += 1
        for k in range(j, r + 1):
            tmp[pos] = nums[k]
            pos += 1
        nums[l:r+1] = tmp[l:r+1]
        return inv_count

    def reversePairs(self, nums: List[int]) -> int:
        n = len(nums)
        tmp = [0] * n
        return self.mergeSort(nums, tmp, 0, n - 1)

169.多数元素【简单】

LeetCode传送门
给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数大于 $\lfloor n/2\rfloor$ 的元素。
你可以假设数组是非空的，并且给定的数组总是存在多数元素。

示例 ：

• 输入: [2,2,1,1,1,2,2]
• 输出: 2

思路：
1. 确定切分的条件：
直到所有的子问题都是长度为 1 的数组，停止切分。

2. 准备数据，将大问题切分为小问题：
递归地将原数组二分为左区间与右区间，直到最终的数组只剩下一个元素，将其返回。

3. 处理子问题得到子结果，并合并：

• 长度为 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
        if nums.count(left)>nums.count(right):
            return left
        else:
            return right

53.最大子序和【简单】

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

示例：

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

思路：
1. 确定切分的条件：
直到所有的子问题都是长度为 1 的数组，停止切分。

2. 准备数据，将大问题切分为小问题：
递归地将原数组二分为左区间与右区间，直到最终的数组只剩下一个元素，将其返回。

3. 处理子问题得到子结果，并合并：

• 将数组切分为左右区间
  • 对左区间：从右到左计算左边的最大子序和
  • 对右区间：从左到右计算右边的最大子序和
• 由于左右区间计算累加和的方向不一致，因此，左右区间直接合并相加之后就是整个区间的和。
• 最终返回左区间的元素、右区间的元素、以及整个区间（相对子问题）和的最大值。

代码：

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

50. Pow(x,n)【中等】

LeetCode传送门
实现 pow(x, n) ，即计算 x 的 n 次幂函数。

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

思路：
$$x^n=\{\begin{array}{l}(x\ast x{)}^{n/2},n\%2==0\\ x\ast (x\ast x{)}^{(n-1)/2},n\%2==1\end{array}$$

1. 确定切分的条件：
对 $n$ 不断除以2，并更新 $n$，直到为0，终止切分。

2. 准备数据，将大问题切分为小问题：
对 $n$ 不断除以2，更新。

3. 处理子问题得到子结果，并合并：

• $x$ 与自身相乘更新 $x$；
• 如果 $n\%2==1$：将 $p$ 乘以 $x$ 之后赋值给 $p$ （初始值为1），返回 $p$。

最终返回 $p$。

代码：

class Solution:
    def myPow(self, x: float, n: int) -> float:
        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)

4. 寻找两个正序数组的中位数【困难】

LeetCode传送门
给定两个大小为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。
请你找出这两个正序数组的中位数，并且要求算法的时间复杂度为 O(log(m + n))。
你可以假设 nums1 和 nums2 不会同时为空。

思路：
在任意位置 $i$ 将 $A$ 划分成两个部分：由于 $A$ 中有 $m$ 个元素，所以有 $m+1$ 种划分的方法（$i\in \{0,\cdots ,m\}$）；
在任意位置 $j$ 将 $B$ 划分成两个部分：由于 $B$ 中有 $n$ 个元素，所以有 $n+1$ 种划分的方法（$j\in \{0,\cdots ,n\}$）；

将 $left\_A$ 和 $left\_B$ 放入一个集合，并将 $right\_A$ 和 $right\_B$ 放入另一个集合。 再把这两个新的集合分别命名为 $left\_part$ 和 $right\_part$，

1.当 $A$ 和 $B$ 的总长度是偶数时，如果：

• $len(left\_part)=len(right\_part)$
• $\max (left\_part)\le \max (right\_part)$

那么，$\{A,B\}$ 中的所有元素已经被划分为相同长度的两个部分，且前一部分中的元素总是小于或等于后一部分中的元素。中位数就是前一部分的最大值和后一部分的最小值的平均值：
$$median=\frac{len(lef{t}_{p}art)+len(righ{t}_{p}art)}{2}$$

2.当 $A$ 和 $B$ 的总长度是奇数时，如果：

• $len(left\_part)=len(right\_part)+1$
• $\max (left\_part)\le \max (right\_part)$

那么，$\{A,B\}$ 中的所有元素已经被划分为两个部分，前一部分比后一部分多一个元素，且前一部分中的元素总是小于或等于后一部分中的元素。中位数就是前一部分的最大值：
$$median=len(left\_part)$$

对于两种情况的第一个条件，

$$\{\begin{array}{l}m+n是偶数：len(left\_part)=len(right\_part)\iff i+j=m-i+n-j\iff i+j=\frac{m+n}{2}\\ m+n是奇数：len(left\_part)=len(right\_part)+1\iff i+j=m-i+n-j+1\iff i+j=\frac{m+n+1}{2}\end{array}$$

可以统一写成：$i+j=\lfloor \frac{m+n+1}{2}\rfloor$

不妨设 $A$ 的长度小于 $B$ 的长度，即$m\le n$。对于任意的 $i\in \{0,\cdots ,m\}$ ，有
$$0=\lfloor \frac{n+n+1}{2}\rfloor -n\le j=\lfloor \frac{m+n+1}{2}\rfloor -i\le \lfloor \frac{n+n+1}{2}\rfloor \le n$$

因此，只需要在 $\{0,\cdots ,m\}$ 内枚举 $i$，并令 $j=\lfloor \frac{m+n+1}{2}\rfloor -i$，这样得到的 $i,j$一定满足第一个条件。

对于两种情况的第二个条件，由于 $A$ 和 $B$ 是有序的，因此这等价于
$$B[j-1]\le A[i]andA[i-1]\le B[j]$$

这里需要注意，对于 $i=0,i=m,j=0,j=n$ 这样的边界点，只需规定 $A[-1]=B[-1]=-\infty ,A[m]=B[m]=+\infty$。这也是比较直观的：当一个数组不出现在前一部分时，对应的值为负无穷，就不会对前一部分的最大值产生影响；当一个数组不出现在后一部分时，对应的值为正无穷，就不会对后一部分的最小值产生影响。

所以我们需要做的是：

在 $\{0,\cdots ,m\}$ 中找到 $i$ ，使得：$B[j-1]\le A[i]andA[i-1]\le B[j]$，其中$j=\lfloor \frac{m+n+1}{2}\rfloor -i$。

现在证明这等价于：

在 $\{0,\cdots ,m\}$ 中找到满足 $A[i-1]\le B[j]$ 的最大的 $i$，其中$j=\lfloor \frac{m+n+1}{2}\rfloor -i$。

这是显然的，因为 $i$ 是满足条件的最大的，意味着 $i+1$ 不满足，即 $A[i]>B[j-1]$。

因此只需要找到满足 $A[i-1]\le B[j]$ 的最大的 $i$来划分数组（二分），进而求中位数。

代码：

class Solution:
    def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
        if len(nums1)>len(nums2):
            return self.findMedianSortedArrays(nums2,nums1)

        infty=2**40
        m,n=len(nums1),len(nums2)
        left,right,ansi=0,m,-1
        median1,median2=0,0 # 前一部分最大值，后一部分最小值

        while left<=right:
            i=(left+right)//2
            j=(m+n+1)//2-i

            nums_im1=-infty if i==0 else nums1[i-1]
            nums_i=infty if i==m else nums1[i]
            nums_jm1=-infty if j==0 else nums2[j-1]
            nums_j=infty if j==n else nums2[j]

            if nums_im1<=nums_j:
                ansi=i
                median1,median2=max(nums_im1,nums_jm1),min(nums_i,nums_j)
                left=i+1
            else:
                right=i-1

        return (median1+median2)/2 if (m+n)%2==0 else median1

932. 漂亮数组【中等】

LeetCode传送门
对于某些固定的 N，如果数组 A 是整数 1, 2, …, N 组成的排列，使得：
对于每个 i < j，都不存在 k 满足 i < k < j 使得 A[k] * 2 = A[i] + A[j]。
那么数组 A 是漂亮数组。
给定 N，返回任意漂亮数组 A（保证存在一个）。

示例：

• 输入：4
• 输出：[2,1,4,3]

思路：
漂亮数组的性质： 如果数组$[a_1,a_2,...,a_n]$是漂亮的，那么对这个数组进行仿射变换，得到的数组$[k{a}_1+b,k{a}_2+b,...,m{a}_n+b]$也是漂亮的（$k\ne 0$）。
证明： 倘若$[k{a}_1+b,k{a}_2+b,\cdots ,k{a}_n+b]$不是漂亮的，则存在 $m$ 满足 $i\le m\le j$，$(k{a}_m+b)\ast 2=(k{a}_i+b)+(k{a}_j+b)$ ，进而有 $a_m\ast 2=a_i+a_j$，这与$[a_1,a_2,\cdots ,a_n]$是漂亮数组矛盾。

构造思路： 将数组分成两部分 $left$ 和 $right$，分别求出一个漂亮的数组，然后将它们进行仿射变换，使得不存在满足下面条件的三元组：

• $A[m]\ast 2=A[i]+A[j],i<m<j$；
• $A[i]$ 来自 $left$ 部分，$A[j]$ 来自 $right$部分。

可以发现，等式 $A[m]\ast 2=A[i]+A[j]$ 的左侧是一个偶数，右侧的两个元素分别来自两个部分。要想等式恒不成立，一个简单的办法就是让 $left$ 部分的数都是奇数，$right$ 部分的数都是偶数。因此我们将所有的奇数放在 $left$ 部分，所有的偶数放在 $right$ 部分，这样可以保证等式恒不成立。

下面考虑如何在两部分 $left$ 和 $right$分别求出漂亮数组。
对于$\{1,2,\cdots ,N\}$ 的排列，$left$ 部分包括 $\lfloor (N+1)/2\rfloor$ 个奇数，$right$ 部分包括$\lfloor N/2\rfloor$个偶数：

• 对于 $left$ 部分，进行 $k=1/2,b=1/2$的仿射变换，把这些奇数映射到不超过 $\lfloor (N+1)/2\rfloor$ 的整数；
• 对于 $right$ 部分，进行 $k=1/2,b=0$的仿射变换，把这些偶数映射到不超过 $\lfloor N/2\rfloor$ 的整数；

经过映射， $left$ 和 $right$ 部分变成了和原问题一样，但规模减少一半的子问题，这样就可以使用分治算法解决了。

代码：

class Solution:
    def beautifulArray(self, N: int) -> List[int]:
        memo={1:[1]}
        def f(N):
            if N not in memo:
                odds=f((N+1)//2)
                evens=f(N//2)
                memo[N]=[2*x-1 for x in odds]+[2*x for x in evens]
            return memo[N]
        return f(N)

参考

Datawhale社区开源教程之leetcode编程实践
LeetCode题解