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

最新推荐文章于 2023-07-21 00:37:52 发布

一只干巴巴的海绵

最新推荐文章于 2023-07-21 00:37:52 发布

阅读量1.5k

点赞数

分类专栏：数据结构

本文链接：https://blog.csdn.net/Hanx09/article/details/108277448

版权

数据结构专栏收录该内容

17 篇文章 1 订阅

订阅专栏

分治算法

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

主要思想

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

分治算法的步骤

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

分治法适用的情况

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

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

伪代码

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

代码：

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{cases} (x*x)^{n/2},\qquad\qquad n\%2==0\\ x*(x*x)^{(n-1)/2},\quad n\%2==1 \end{cases}$

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)\leq\max(right\_part)$

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

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

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

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

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

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

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

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

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

对于两种情况的第二个条件，由于 $A$ 和 $B$ 是有序的，因此这等价于
$B[j-1]\leq A[i] \quad and \quad A[i-1]\leq 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]\leq A[i] \quad and \quad A[i-1]\leq B[j]$ ，其中 $j=\lfloor \frac{m+n+1}{2}\rfloor-i$ 。

现在证明这等价于：

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

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

因此只需要找到满足 $A[i-1]\leq 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]$ 是漂亮的，那么对这个数组进行仿射变换，得到的数组 $ka_1+b,ka_2+b,...,ma_n+b]$ 也是漂亮的（ $k\neq0$ ）。
证明： 倘若 $[ka_1+b,ka_2+b,\cdots,ka_n+b]$ 不是漂亮的，则存在 $m$ 满足 $i\leq m\leq j$ ， $ka_m+b)*2=(ka_i+b)+(ka_j+b)$ ，进而有 $a_m*2=a_i+a_j$ ，这与 $[a_1,a_2,\cdots,a_n]$ 是漂亮数组矛盾。

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

$A[m]*2=A[i]+A[j],\quad i<m<j$ ；
$A [i]$ 来自 $l e f t$ 部分， $A [j]$ 来自 $r i g h t$ 部分。

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

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

对于 $l e f t$ 部分，进行 $k = 1 / 2, b = 1 / 2$ 的仿射变换，把这些奇数映射到不超过 $\lfloor (N+1)/2\rfloor$ 的整数；
对于 $r i g h t$ 部分，进行 $k = 1 / 2, b = 0$ 的仿射变换，把这些偶数映射到不超过 $\lfloor N/2\rfloor$ 的整数；

经过映射， $l e f t$ 和 $r i g h t$ 部分变成了和原问题一样，但规模减少一半的子问题，这样就可以使用分治算法解决了。

代码：

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)