分治
基本概念
在计算机科学中,分治法是一种很重要的算法。字面上的解释是“分而治之”,就是把一个复杂的问题分成两个或更多的相同或相似的子问题,再把子问题分成更小的子问题……直到最后子问题可以简单的直接求解,原问题的解即子问题的解的合并。这个技巧是很多高效算法的基础,如排序算法(快速排序,归并排序),傅立叶变换(快速傅立叶变换)……
主要思想
分治算法的主要思想是将原问题递归地分成若干个子问题,直到子问题满足边界条件,停止递归。将子问题逐个击破(一般是同种方法),将已经解决的子问题合并,最后,算法会层层合并得到原问题的答案。
分治策略
对于一个规模为n的问题,若该问题可以容易地解决(比如说规模n较小)则直接解决,否则将其分解为k个规模较小的子问题,这些子问题互相独立且与原问题形式相同,递归地解这些子问题,然后将各子问题的解合并得到原问题的解。这种算法设计策略叫做分治法。
分治算法的步骤
- 分:递归地将问题分解为各个的子问题(性质相同的、相互独立的子问题);
- 治:将这些规模更小的子问题逐个击破;
- 合:将已解决的子问题逐层合并,最终得出原问题的解;
分治法适用的情况
- 原问题的计算复杂度随着问题的规模的增加而增加。
- 原问题能够被分解成更小的子问题。
- 子问题的结构和性质与原问题一样,并且相互独立,子问题之间不包含公共的子子问题。
- 原问题分解出的子问题的解可以合并为该问题的解。
举例
通过应用举例分析理解分治算法的原理其实并不难,但是要想灵活应用并在编程中体现这种思想中却并不容易。所以,这里这里用分治算法应用在排序的时候的一个栗子,加深对分治算法的理解。
相关概念:
- 有序度:表示一组数据的有序程度
- 逆序度:表示一组数据的无序程度
一般通过计算有序对或者逆序对的个数,来表示数据的有序度或逆序度。
假设我们有 n
个数据,我们期望数据从小到大排列,那完全有序的数据的有序度就是 n(n-1)/2
,逆序度等于 0;相反,倒序排列的数据的有序度就是 0,逆序度是 n(n-1)/2
。
Q:如何编程求出一组数据的有序对个数或者逆序对个数呢?
因为有序对个数和逆序对个数的求解方式是类似的,所以这里可以只思考逆序对(常接触的)个数的求解方法。
- 方法1
- 拿数组里的每个数字跟它后面的数字比较,看有几个比它小的。
- 把比它小的数字个数记作
k
,通过这样的方式,把每个数字都考察一遍之后,然后对每个数字对应的k
值求和 - 最后得到的总和就是逆序对个数。
- 这样操作的时间复杂度是 O ( n 2 ) O(n^2) O(n2)(需要两层循环过滤)。那有没有更加高效的处理方法呢?这里尝试套用分治的思想来求数组 A 的逆序对个数。
# 两层循环嵌套,时间复杂度为O(n^2),不可取
def sortNum(nums):
'''
:param nums:List[int]
:return: int
'''
totleCount = 0
while len(nums) > 1:
newNums = nums[1:]
count = 0
for item in newNums:
if nums[0] > item: # 首个元素大于后面元素,则为逆序,计数+1
count += 1
totleCount += count
nums = newNums
return totleCount
list = [3, 2, 3]
print(sortNum(list)) # 1
- 方法2
- 首先将数组分成前后两半 A1 和 A2,分别计算 A1 和 A2 的逆序对个数 K1 和 K2
- 然后再计算 A1 与 A2 之间的逆序对个数 K3。那数组 A 的逆序对个数就等于 K1+K2+K3。
- 注意使用分治算法其中一个要求是,子问题合并的代价不能太大,否则就起不了降低时间复杂度的效果了。
- **如何快速计算出两个子问题 A1 与 A2 之间的逆序对个数呢?这里就要借助归并排序算法了。(这里先回顾一下归并排序思想)**如何借助归并排序算法来解决呢?归并排序中有一个非常关键的操作,就是将两个有序的小数组,合并成一个有序的数组。实际上,在这个合并的过程中,可以计算这两个小数组的逆序对个数了。每次合并操作,我们都计算逆序对个数,把这些计算出来的逆序对个数求和,就是这个数组的逆序对个数了。
def CountInv(list):
count = 0
splice_point = len(list) // 2
if splice_point == 0:
return list, 0
left, leftInv = CountInv(list[:splice_point]) # 左序列逆序对的数量
right, rightInv = CountInv(list[splice_point:]) # 右序列逆序对的数量
list, spliteInv = CountSpliteInv(left, right, count) # 分离逆序对的数量
count = leftInv + rightInv + spliteInv
return list, count
def CountSpliteInv(left, right, count):
i = j = 0
list = []
while i < len(left) and j < len(right):
if left[i] < right[j]:
list.append(left[i])
i += 1
else:
list.append(right[j])
j += 1
# 当分解到左边和右边只有1个元素时,并且左边元素大于右边,很明显此时只有1个逆序对
if len(left) == 1 and len(right) == 1:
count = 1
else:
count += len(left) - i
list += left[i:]
list += right[j:]
return list, count
list = [1, 7, 4, 5, 3]
list, count = CountInv(list)
print('排序后的结果:', list)
print('逆序对的数量:', count)
'''
排序后的结果: [1, 3, 4, 5, 7]
逆序对的数量: 3
'''
算法应用
1.多数元素
-
题目描述
给定一个大小为 n 的数组,找到其中的众数。众数是指在数组中出现次数大于 [n/2] 的元素。
你可以假设数组是非空的,并且给定的数组总是存在众数。
示例 1:
输入: [3,2,3] 输出: 3
示例 2:
输入: [2,2,1,1,1,2,2] 输出: 2
-
解题思路
-
确定切分的终止条件
直到所有的子问题都是长度为 1 的数组,停止切分。
-
准备数据,将大问题切分为小问题
递归地将原数组二分为左区间与右区间,直到最终的数组只剩下一个元素,将其返回
-
处理子问题得到子结果,并合并
- 长度为 1 的子数组中唯一的数显然是众数,直接返回即可。
- 如果它们的众数相同,那么显然这一段区间的众数是它们相同的值。
- 如果他们的众数不同,比较两个众数在整个区间内出现的次数来决定该区间的众数
-
def majorityElement2(nums):
'''
:param nums:List[int]
:return: int
'''
splice_point = len(nums) // 2
# 数组元素个数为1,直接返回唯一元素,即为众数
if splice_point == 0:
return nums[0]
left = majorityElement2(nums[:splice_point])
right = majorityElement2(nums[splice_point:])
if left == right:
# 左右众数相同,即为众数
return left
#左侧众数在整个序列中出现次数更多,返回left
if nums.count(left) > nums.count(right):
return left
else:
return right
list = [3,2,3]
print(majorityElement2(list)) # 3
list1 = [2,2,1,1,1,2,2]
print(majorityElement2(list1)) # 2
2. 最大子序和
-
题目描述
给定一个整数数组
nums
,找到一个具有最大和的连续子数组(子数组最少包含一个元素),返回其最大和。示例:
输入: [-2,1,-3,4,-1,2,1,-5,4], 输出: 6 解释: 连续子数组 [4,-1,2,1] 的和最大为6。
-
解题思路
-
确定切分的终止条件
直到所有的子问题都是长度为 1 的数组,停止切分。
-
准备数据,将大问题切分为小问题
递归地将原数组二分为左区间与右区间,直到最终的数组只剩下一个元素,将其返回
-
处理子问题得到子结果,并合并
- 将数组切分为左右区间
- 对与左区间:从右到左计算左边的最大子序和
- 对与右区间:从左到右计算右边的最大子序和
- 由于左右区间计算累加和的方向不一致,因此,左右区间直接合并相加之后就是整个区间的和
- 最终返回左区间的元素、右区间的元素、以及整个区间(相对子问题)和的最大值
- 将数组切分为左右区间
-
def maxSubArray(nums):
'''
:param nums:List[int]
:return: int
'''
splice_point = len(nums) // 2
# 数组元素个数为1,直接返回唯一元素,即为该分组的最大值
if splice_point == 0:
return nums[0]
left = maxSubArray(nums[:splice_point])
right = maxSubArray(nums[splice_point:])
# 分治:处理子问题,从右向左计算最大子序和
max_l = nums[splice_point - 1] # 左区间最右侧元素
result = 0
for item in range(splice_point - 1,-1,-1):
result += nums[item]
max_l = max(result,max_l)
# 分治:处理子问题,从左向右计算最大子序和
max_r = nums[splice_point]
result = 0
for item in range(splice_point,len(nums)):
result += nums[item]
max_r = max(result,max_r)
# 合并: 现有三个最大值:left(只计算最左侧);right(只计算最右侧);max_l+max_r(左右两侧合并所得的最大值)
# 返回三个数中的最大值
return max(left,right,max_l + max_r)
list = [-2,1,-3,4,-1,2,1,-5,4]
print(maxSubArray(list)) # 6
学习讨论过程中,发现分治算法对于解决此题并不是一种特别好的方式,贪心算法和动态规划在解决此问题时更简单
- 解法二:动态规划
def maxSubArray(nums):
"""
:type nums: list[int]
:rtype: int
"""
for i in range(1, len(nums)):
nums[i] = nums[i] + max(nums[i - 1], 0)
return max(nums)
list1 = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
print(maxSubArray(list1)) # 6
- 解法三:贪心算法
# 照搬队长的代码来学习,在此表示感谢
def maxSubArray(nums):
"""
:type nums: list[int]
:rtype: int
"""
if max(nums) < 0:
return max(nums)
curr_sum, max_sum = 0, 0
for n in nums:
if curr_sum < 0:
curr_sum = n
else:
curr_sum += n
max_sum = max(curr_sum, max_sum)
return max_sum
list1 = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
print(maxSubArray(list1))
3. Pow(x, n)
-
题目描述
实现
pow(x, n)
,即计算x
的n
次幂函数。示例 1:
输入: 2.00000, 10 输出: 1024.00000
示例 2:
输入: 2.10000, 3 输出: 9.26100
示例 3:
输入: 2.00000, -2 输出: 0.25000 解释: 2-2 = 1/22 = 1/4 = 0.25
说明:
-100.0 < x < 100.0
n
是 32 位有符号整数,其数值范围是[−2^{31}, 2^{31} − 1]
。 -
解题思路
-
确定切分的终止条件
对
n
不断除以2,并更新n
,直到为0,终止切分 -
准备数据,将大问题切分为小问题
对
n
不断除以2,更新 -
处理子问题得到子结果,并合并
-
x
与自身相乘更新x
-
如果
n%2 ==1
- 将
p
乘以x
之后赋值给p
(初始值为1),返回p
- 将
-
-
最终返回
p
-
def pow(x, n):
'''
:param x:float
:param n: int
:return: float
'''
# 考虑特殊情况:n < 0;n = 0
if n < 0:
x = 1 / x
n = -n
if n == 0:
return 1
# 分治:对n不断折半切分,化为幂指数减半的子问题,若n为奇,则先计算(n-1)次幂再折半
if n % 2 == 1:
return x * pow(x, n - 1)
return pow(x * x, n / 2)
x, n = 2.00000, 10
print(pow(x, n))
x, n = 2.10000, 3
print(pow(x, n)) # 9.26100
x, n = 2.00000, -2
print(pow(x, n)) # 0.25000