一、什么是分治算法
分治算法的主要思想是将原问题递归地分成若干个子问题,直到子问题满足边界条件,停止递归。将子问题逐个击破(一般是同种方法),将已经解决的子问题合并,最后,算法会层层合并得到原问题的答案
分治算法的主要步骤
- 分:递归地将问题分解为各个的子问题(性质相同的、相互独立的子问题);
- 治:将这些规模更小的子问题逐个击破;
- 合:将已解决的子问题逐层合并,最终得出原问题的解;
分治法适用的情况
- 原问题的计算复杂度随着问题的规模的增加而增加。
- 原问题能够被分解成更小的子问题。
- 子问题的结构和性质与原问题一样,并且相互独立,子问题之间不包含公共的子子问题。
- 原问题分解出的子问题的解可以合并为该问题的解。
算法伪代码
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,...)
二、算法应用
1.力扣169.多数元素【传送门】
解法1:分治法
解题思路
-
确定切分的终止条件
直到所有的子问题都是长度为 1 的数组,停止切分。 -
准备数据,将大问题切分为小问题
递归地将原数组二分为左区间与右区间,直到最终的数组只剩下一个元素,将其返回 -
处理子问题得到子结果,并合并
- 长度为 1 的子数组中唯一的数显然是众数,直接返回即可。
- 如果它们的众数相同,那么显然这一段区间的众数是它们相同的值。
- 如果他们的众数不同,比较两个众数在整个区间内出现的次数来决定该区间的众数
代码
class Solution(object):
def majorityElement2(self, nums):
"""
:type nums: List[int]
:rtype: 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
解法2:暴力解法(排序后直接返回中间的位置)
代码
class Solution:
def majorityElement(self, nums: List[int]) -> int:
nums.sort()
return nums[len(nums)//2]
解法3:投票法【参考链接】
算法复杂度:时间复杂度 O(N) : N 为数组 nums 长度。空间复杂度 O(1) : votes 变量使用常数大小的额外空间。
代码
class Solution:
def majorityElement(self, nums: List[int]) -> int:
# nums.sort()
# return nums[len(nums)//2]
votes = 0
for num in nums:
if votes == 0:#初始化
x = num
if num == x:
votes += 1
else:
votes -= 1
return x
2.最大子序和【传送门】
注意这边的是连续子数组,还有另外一道题是上升的子序列,注意区分,在动态规划中我们会涉及到。
解法1. 分治法
解题思路
-
确定切分的终止条件
直到所有的子问题都是长度为 1 的数组,停止切分。
-
准备数据,将大问题切分为小问题
递归地将原数组二分为左区间与右区间,直到最终的数组只剩下一个元素,将其返回
-
处理子问题得到子结果,并合并
-
将数组切分为左右区间
- 对与左区间:从右到左计算左边的最大子序和
- 对与右区间:从左到右计算右边的最大子序和
-
由于左右区间计算累加和的方向不一致,因此,左右区间直接合并相加之后就是整个区间的和
-
最终返回左区间的元素、右区间的元素、以及整个区间(相对子问题)和的最大值
-
代码
class Solution(object):
def maxSubArray(self, nums):
"""
:type nums: List[int]
:rtype: 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] # 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)
解法2.动态规划
class Solution:
def maxSubArray(self, nums: List[int]) -> int:
# 原地修改数组,动态规划
maxnum = nums[0]
for i in range(1,len(nums)):
if nums[i-1] > 0:
nums[i] += nums[i-1]
maxnum = max(maxnum,nums[i])
return maxnum
3.Pow(x,n)【传送门】
解法1.分治法
解题思路
-
确定切分的终止条件
对
n
不断除以2,并更新n
,直到为0,终止切分 -
准备数据,将大问题切分为小问题
对
n
不断除以2,更新 -
处理子问题得到子结果,并合并
x
与自身相乘更新x
- 如果
n%2 ==1
- 将
p
乘以x
之后赋值给p
(初始值为1),返回p
- 将
-
最终返回
p
class Solution(object):
def myPow(self, x, n):
"""
:type x: float
:type n: int
:rtype: float
"""
# 处理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)
解法2. 快速幂解析(二进制角度)参考链接
class Solution:
def myPow(self, x: float, n: int) -> float:
if x == 0.0: return 0.0
res = 1
if < 0: x, n = 1 / x, -n
while n:
if n & 1: res *= x
x *= x
n >>= 1
return res
复杂度分析:
时间复杂度 O(logn) : 二分的时间复杂度为对数级别。
空间复杂度 O(1) : rres等变量占用常数大小额外空间。