LeetCode编程实践 分治算法
分治
基本概念
在计算机科学中，分治法是一种很重要的算法。字面上的解释是“分而治之”，就是把一个复杂的问题分成两个或更多的相同或相似的子问题，再把子问题分成更小的子问题……直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。这个技巧是很多高效算法的基础，如排序算法(快速排序，归并排序)，傅立叶变换(快速傅立叶变换)……
主要思想
分治算法的主要思想是将原问题递归地分成若干个子问题，直到子问题满足边界条件，停止递归。将子问题逐个击破(一般是同种方法)，将已经解决的子问题合并，最后，算法会层层合并得到原问题的答案。
分治策略
对于一个规模为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)) # 22. 最大子序和
-
题目描述
给定一个整数数组
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.0n是 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