Leetcode分类练习-分治

分治

引文
MapReduce（分冶算法的应用）是Google大数据处理的三驾马车之一，另外两个是GFS和Bigtable。它在倒排索引、PageRank计算、网页分析等搜索引擎相关的技术中都有大量应用。

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

分治算法的步骤

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

分治法使用的情况

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

伪代码

def divide_conquer(problem, param1, 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...)

举个例子
相关概念

• 有序度：表示一组数据的有序程度
• 逆序度：表示一组数据的无序程度

一般通过计算有序对或者逆序对的个数，来表示数据的有序度或者逆序度
假设有n个数据，我们期望数据从小到大排列，那完全有序的数据的有虚度就是$n(n-1)/2$,逆序读为0。如果该数据从大到小排列，那么有序度和逆序度则反之。

提问：如何编程求出一组数据的有序对个数或者逆序对的个数呢？
因为有序队个数和逆序对个数的求解方式是类似的，所以这里可以只考虑逆序对个数的求解方法。

• 方法
  首先将数组分为前后两半，A1和A2，分别计算A1和A2的逆序对个数k1和k2；
  然后再计算A1与A2之间的逆序对个数k3，那数组A的逆序对个数就是k1+k2+k3；
  使用分冶算法其中一个要求是，字问题合并的代价不能太大，否则起不到降低时间复杂度的作用。

如何快速计算两个字问题A1和A2之间的逆序对个数呢？这里就要借助归并排序算法了
归并排序中有一个非常关键的操作，就是将两个有序的小数组，合并成一个有序的数组。实际上，在这歌合并的过程汇总，可以计算这两个小数组的逆序对个数了。每次合并操作我们都计算逆序对个数，把这些计算出来的逆序对个数求和，就是最终答案。

算法应用
1、题目描述
给定一个大小为n的数组，找到其中的众数，众数是指在数组中出现次数大于n/2的元素。你可以假设数组是非空的，并且给定的数组总是存在众数。
示例1:

input: [3,2,3]
output:3

示例2:

input:[2,2,1,1,1,2,2]
output:2

2、解题思路
确定切分的终止条件：知道所有的字问题都是长度为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

运行结果：

solution = Solution()
nums = [1,3,4,5,5,5,6]
x = solution.majorityElement2(nums)
print(x)
5

最大子序列和
1、题目描述
给定一个整数数组nums，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
示例1:

input :[-2, 1, -3, 4, -1, 2, 1, -5, 4]
output: 6
解释：连续子数组[4, -1, 2, 1]的和最大为6.

2、解题思路
确定切分的终止条件：直到所有的字问题都是长度为1的数组，停止切分。准备数据，将大问题切分为小问题：递归地将原数组二分为左区间和右区间，直到最终的数组只剩下一个元素将其返回。
处理子问题得到子结果，并合并。
将数组分为左右区间，对与左区间从右到左计算左边的最大子序和，对与右区间，从右到左计算右边的最大子序和。
由于左右区间计算累加和的方向不一致，因此左右区间直接合并相加之后就是整个区间的和。
最终返回左区间的元素、右区间的元素、以及整个区间（相对子问题）和的最大值。

3、代码

class Solution(object):
	"""
	: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

	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) 

Pow(x,n)
1、题目描述
实现pow(x,n), 也就是计算x的n次幂函数。
示例1：

输入：2.00000， 10
输出：1024.0000

示例2:

输入：2.10000，3
输出：9.26100

示例3:

输入:2.0000, -2
输出：0.25000
解释：1/4 = 0.25

说明：
-100.0 < x < 100.0，n是32位有符号整数，其数值范围是$[-2^{31},2^{31}-1]$

2、解题思路
确定切分的终止条件，对n不断除以2，更新n直到0，终止切分。
准备数据：将大问题切分为小问题：对n不断除以2， 更新
处理子问题得到子结果，并合并。
x与自身相乘更新x
如果n%2 == 1，将p乘以x之后赋值给p（初始值也为1），返回p
最终返回p

代码：

class Solution(object):
    def pow_value(self, x, n):
        """
        :type: x: float
        :type n: int
        :rtype: float
        """
        #【确定不断切分的终止条件】
        if n < 0:
            x = 1/x
            n = -n
            
        #if n == 1:
         #   return 
        
        if n == 0:
            return 1
        
        #【准备数据并将大问题拆分为小问题】
        if n%2 == 1:
            #【处理小问题得到字子结果】
            p = x * self.pow_value(x, n-1)
            return p
        else:
            return x*self.pow_value(x, n/2)

solution = Solution()
x = 10
n = 3
y = solution.pow_value(x, n)
print(y)