编程实践——分治算法

1. 代码模板

def divide_conquer(problem,param1,param2):
	#recursion tereminator
	if problem is None:
	print_result
	return

	#prepare data
	data = prepare_data(problem)
	subproblems = split_problem(problem,data)

	#conquer subproblems
	subresult1 = self.divide_conquer(subproblems[0],p1,p2)
	subresult2 = self.divide_conquer(subproblems[1],p1,p2)
	subresult3 = self.divide_conquer(subproblems[2],p1,p2)
	
	#process and generate the final result
	result = process_result(subresult1,subresult2,subresult3)

	#revert the current level

50.pow(x,n)

#对半分，如果是偶数则 res*res 如果是奇数 则res*res*x
class Solution(object):
    def myPow(self, x, n):
    	def quickmul(x,n):
    		#terminator
    		if n == 0:
    			return 1.0 
    		res = quickmul(x, n//2)
    		return res * res if n % 2 == 0 else res * res * x
    	return quickmul(x,n) if n >= 0 else 1.0/quickmul(x,-n)
    

169.多数元素

#有很多种方法
#1.hasp_map 
#2.quick_sort
#3.摩尔投票法
#4.分治法
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    

53.最大子序和

#1.动态规划 dp[i] = max(dp[i-1]+nums[i],nums[i])
#2.分治算法
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)