创作来自于DataWhale组队学习活动,由于分治算法学习文档对分治算法介绍地很完美了,所以内容以搬运为主,并增加LeetCode官方的其他解题思路
分治算法介绍
分治算法思想
分治算法的主要思想是将原问题递归地分成若干个子问题,直到子问题满足边界条件,停止递归。将子问题逐个击破(一般是同种方法),将已经解决的子问题合并,最后,算法会层层合并得到原问题的答案。
分治算法的步骤
- 分:递归地将问题分解为各个的子问题(性质相同的、相互独立的子问题);
- 治:将这些规模更小的子问题逐个击破;
- 合:将已解决的子问题逐层合并,最终得出原问题的解;
分类算法适用的情况
- 原问题的计算复杂度随着问题的规模的增加而增加。
- 原问题能够被分解成更小的子问题。
- 子问题的结构和性质与原问题一样,并且相互独立,子问题之间不包含公共的子子问题。
- 原问题分解出的子问题的解可以合并为该问题的解。
举个栗子
用分治算法应用在排序的时候的一个栗子,加深对分治算法的理解。
相关概念:
- 有序度:表示一组数据的有序程度
- 逆序度:表示一组数据的无序程度
一般通过计算有序对或者逆序对的个数,来表示数据的有序度或逆序度。
假设我们有 n 个数据,我们期望数据从小到大排列,那完全有序的数据的有序度就是
n
(
n
−
1
)
/
2
n(n-1)/2
n(n−1)/2,逆序度等于 0;相反,倒序排列的数据的有序度就是 0,逆序度是
n
(
n
−
1
)
/
2
n(n-1)/2
n(n−1)/2。
Q:如何编程求出一组数据的有序对个数或者逆序对个数呢?
因为有序对个数和逆序对个数的求解方式是类似的,所以这里可以只思考逆序对个数的求解方法。
- 方法1:
- 拿数组里的每个数字跟它后面的数字比较,看有几个比它小的。
- 把比它小的数字个数记作 k,通过这样的方式,把每个数字都考察一遍之后,然后对每个数字对应的 k 值求和最后得到的总和就是逆序对个数。
- 这样操作的时间复杂度是 O ( n 2 ) O(n^2) O(n2)(需要两层循环过滤)。那有没有更加高效的处理方法呢?这里尝试套用分治的思想来求数组 A 的逆序对个数。
- 方法2
- 首先将数组分成前后两半 A1 和 A2,分别计算 A1 和 A2 的逆序对个数 K1 和 K2
- 然后再计算 A1 与 A2 之间的逆序对个数 K3。那数组 A 的逆序对个数就等于 K1+K2+K3。
- 注意使用分治算法其中一个要求是,子问题合并的代价不能太大,否则就起不了降低时间复杂度的效果了。
- 如何快速计算出两个子问题 A1 与 A2 之间的逆序对个数呢?这里就要借助归并排序算法了。(这里先回顾一下归并排序思想)**如何借助归并排序算法来解决呢?归并排序中有一个非常关键的操作,就是将两个有序的小数组,合并成一个有序的数组。实际上,在这个合并的过程中,可以计算这两个小数组的逆序对个数了。每次合并操作,我们都计算逆序对个数,把这些计算出来的逆序对个数求和,就是这个数组的逆序对个数了。
LeetCode实践
169.多数元素
- 题目描述
给定一个大小为 n 的数组,找到其中的众数。众数是指在数组中出现次数大于 [n/2] 的元素(算法中众数的定义)。
你可以假设数组是非空的,并且给定的数组总是存在众数。 - 解题思路
-
确定切分的终止条件
直到所有的子问题都是长度为 1 的数组,停止切分。 -
准备数据,将大问题切分为小问题
递归地将原数组二分为左区间与右区间,直到最终的数组只剩下一个元素,将其返回 -
处理子问题得到子结果,并合并
- 长度为 1 的子数组中唯一的数显然是众数,直接返回即可。
- 如果它们的众数相同,那么显然这一段区间的众数是它们相同的值。
- 如果他们的众数不同,比较两个众数在整个区间内出现的次数来决定该区间的众数
-
- 代码
class Solution:
def majorityElement(self, nums: List[int]) -> int:
if not nums:
return None
# 确定切分的终止条件
# 直到所有的问题都是长度为1的数组,停止切分
if len(nums)==1:
# 最简单的子问题:长度为 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.最大子序和
- 题目描述
给定一个整数数组 nums ,找到一个具有最大和的连续子数组(子数组最少包含一个元素),返回其最大和。 - 解题思路
- 确定切分的终止条件
直到所有的子问题都是长度为 1 的数组,停止切分。 - 准备数据,将大问题切分为小问题
递归地将原数组二分为左区间与右区间,直到最终的数组只剩下一个元素,将其返回 - 处理子问题得到子结果,并合并
- 对与左区间:从右到左计算左边的最大子序和
- 对与右区间:从左到右计算右边的最大子序和
- 由于左右区间计算累加和的方向不一致,因此,左右区间直接合并相加之后就是整个区间的和,最终返回左区间的元素、右区间的元素、以及整个区间(相对子问题)和的最大值。
- 确定切分的终止条件
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(max_l,tmp)
# 从左至右计算右边的最大子序和
max_r=nums[len(nums)//2]
tmp=0
for i in range(len(nums)//2,len(nums),1):
tmp+=nums[i]
max_r=max(max_r,tmp)
# 对子问题的结果进行合并
# 返回这三个中的最大值
return max(left,right,max_l + max_r)
50.求x的n次幂
-
题目描述
实现 pow(x, n) ,即计算 x 的 n 次幂函数。 -
官方思路1:快速幂+递归
快速幂算法的本质是分治算法。举个例子,如果我们要计算
x
64
x^{64}
x64,我们可以按照:
x
→
x
2
→
x
4
→
x
8
→
x
16
→
x
32
→
x
64
x \to x^2 \to x^4 \to x^8 \to x^{16} \to x^{32} \to x^{64}
x→x2→x4→x8→x16→x32→x64的顺序,从 x开始,每次直接把上一次的结果进行平方,计算 6 次就可以得到
x
64
x^{64}
x64 的值,而不需要对 x 乘 63 次x 。
再举一个例子,如果我们要计算
x
77
x^{77}
x77,我们可以按照:
x
→
x
2
→
x
4
→
x
9
→
x
19
→
x
38
→
x
77
x \to x^2 \to x^4 \to x^9 \to x^{19} \to x^{38} \to x^{77}
x→x2→x4→x9→x19→x38→x77的顺序,在这些步骤中,其中
x
→
x
2
x \to x^2
x→x2,
x
2
→
x
4
x^2 \to x^4
x2→x4,
x
19
→
x
38
x^{19} \to x^{38}
x19→x38,我们直接把上一次的结果进行平方,而在
x
4
→
x
9
,
x
9
→
x
19
,
x
38
→
x
77
x^4 \to x^9,x^9 \to x^{19},x^{38} \to x^{77}
x4→x9,x9→x19,x38→x77这些步骤中,我们把上一次的结果进行平方后,还要额外乘一个 x。
直接从左到右进行推导看上去很困难,因为在每一步中,我们不知道在将上一次的结果平方之后,还需不需要额外乘 xx。但如果我们从右往左看,分治的思想就十分明显了:
-
当我们要计算 x n x^n xn时,我们可以先递归地计算出 y = x ⌊ n / 2 ⌋ y = x^{\lfloor n/2\rfloor} y=x⌊n/2⌋,其中 ⌊ a ⌋ \lfloor a\rfloor ⌊a⌋表示对 a 进行下取整;
-
根据递归计算的结果,如果 n 为偶数,那么 $x^n = y^2;如果 n 为奇数,那么 x n = y 2 ∗ x x^n = y^2 * x xn=y2∗x;
-
递归的边界为 n = 0,任意数的 0 次方均为 1。
来源:力扣官方题解(LeetCode) -
代码
class Solution:
def myPow(self, x: float, n: int) -> float:
# 思路1:快速幂+递归
# 处理n小于0的情况
if n<0:
x=1/x
n=-n
# 确定不断切分的终止条件
if n==0:
return 1
# 准备数据,将大问题切分为小问题
p=self.myPow(x,n//2)
# 处理小问题,得到子问题结果
# 如果n除以2有余数1,则需要多乘一个x
if n%2==1:
return p*p*x
else:
return p*p
-
复杂度分析:
- 时间复杂度: O ( l o g n ) O(logn) O(logn),即为递归的层数。
- 空间复杂度: O ( l o g n ) O(logn) O(logn),即为递归的层数。这是由于递归的函数调用会使用栈空间。
-
递归执行逻辑
-
官方思路2:快速幂+迭代
由于递归需要使用额外的栈空间,我们试着将递归转写为迭代我们还是以 x 77 x^{77} x77作为例子:
x → x 2 → x 4 → + x 9 → + x 19 → x 38 → + x 77 x \to x^2 \to x^4 \to^+ x^9 \to^+ x^{19} \to x^{38} \to^+ x^{77} x→x2→x4→+x9→+x19→x38→+x77
把需要额外乘 x的步骤打上了 ++ 标记。可以发现: -
x 38 → + x 77 x^{38} \to^+ x^{77} x38→+x77中额外乘的 x 在 x 77 x^{77} x77中贡献了 x;
-
x 9 → + x 19 x^9 \to^+ x^{19} x9→+x19中额外乘的 x 在之后被平方了 2 次,因此在 x 77 x^{77} x77中贡献了 x 4 x^4 x4
-
x 4 → + x 9 x^4 \to^+ x^9 x4→+x9中额外乘的 x在之后被平方了 3 次,因此在 x 77 x^{77} x77中贡献了 x 8 x^8 x8
-
最初的 x 在之后被平方了 66 次,因此在 x 77 x^{77} x77中贡献了 x 64 x^{64} x64
我们把这些贡献相乘,
x
∗
x
4
∗
x
8
∗
x
64
x * x^4 * x^8 * x^{64}
x∗x4∗x8∗x64 恰好等于
x
77
x^{77}
x77。而这些贡献的指数部分又是什么呢?它们都是 2 的幂次,这是因为每个额外乘的 x 在之后都会被平方若干次。而这些指数 1,4,8 和 64,恰好就对应了 77的二进制表(1001101)_2
中的每个 1!
因此我们借助整数的二进制拆分,就可以得到迭代计算的方法,一般地,如果整数 n 的二进制拆分为
n = 2 i 0 + 2 i 1 + ⋯ + 2 i k n = 2^{i_0} + 2^{i_1} + \cdots + 2^{i_k} n=2i0+2i1+⋯+2ik
那么
x n = x 2 i 0 ∗ x 2 i 1 ∗ ⋯ ∗ x 2 i k x^n = x^{2^{i_0}} * x^{2^{i_1}} * \cdots * x^{2^{i_k}} xn=x2i0∗x2i1∗⋯∗x2ik
这样以来,我们从 x 开始不断地进行平方,得到
x
2
,
x
4
,
x
8
,
x
16
,
⋯
x^2, x^4, x^8, x^{16}, \cdots
x2,x4,x8,x16,⋯如果 n 的第 k 个(从右往左,从 0 开始计数)二进制位为 1,那么我们就将对应的贡献
x
2
k
x^{2^k}
x2k 计入答案。
来源:力扣(LeetCode)
- 代码
class Solution:
def myPow(self, x: float, n: int) -> float:
def quickMul(N):
ans = 1.0
# 贡献的初始值为 x
x_contribute = x
# 在对 N 进行二进制拆分的同时计算答案
while N > 0:
if N % 2 == 1:
# 如果 N 二进制表示的最低位为 1,那么需要计入贡献
ans *= x_contribute
# 将贡献不断地平方
x_contribute *= x_contribute
# 舍弃 N 二进制表示的最低位,这样我们每次只要判断最低位即可
N //= 2
return ans
return quickMul(n) if n >= 0 else 1.0 / quickMul(-n)
-
时间复杂度:
- 时间复杂度: O ( l o g n ) O(logn) O(logn),即为对 n 进行二进制拆分的时间复杂度。
- 空间复杂度: O ( 1 ) O(1) O(1)。
时间有限,主要自己太菜,所以只最后一题写了官方的思路,开始两道题直接写的学习文档上的思路,没有写LeetCode官方思路,要打卡了