分治策略----最大子数组问题

归并排序的本质–分治策略

我们之前介绍了归并排序，而归并排序的本质就是分治策略，将一个大的问题，分解成若干个相同的小问题，通过小问题的求解，进而逆推解决大问题。在分治策略中，我们通常采用递归的方法对问题进行求解，而每层的递归中都包含三个步骤：
分解：将问题划分为一些子问题，子问题的形式与原问题一样，只是问题的规模变小，简单来说，就是将问题涉及的数据维度进行划分，每个子问题包含原问题的一定数量的数据，并且按原问题的要求处理，即子问题与原问题相同，只是处理的数据维度，数据量更小而已。
解决：递归地求解子问题。如果子问题的规模够小，则停止递归，直接求解。
合并：将子问题的解组合成原问题的解。子问题将原问题的数据进行划分，并且按原问题的要求进行处理，使得子问题的解与原问题的解一定是相关的，则可以通过对子问题的解进行一定操作处理后得到原问题的解。
由解决步骤可以知道，当子问题规模足够大时，将进行递归求解，我们称之为递归情况，而问题的规模将在递归求解的进行下不断变小，当问题的规模变得足够小时，我们将不再需要进行递归，说明递归已经“触底”，进入了基本情况。
需要强调的是，有时，除了与原问题形式完全相同的规模更小的子问题外，我们还需要求解与原问题不完全一样的子问题。我们将这些子问题的求解看做合并步骤的一部分。在归并排序中，我们的原问题是将数组按顺序进行排序，我们取下标中值，将原问题进行划分，产生两个子数组，生成新的子问题，这个子问题与原问题除规模外完全相同，目的同样是将数组按顺序进行排序，但我们在通过子问题的解逆推原问题解的时候，将遇到一个新的问题，如何将两个已经排好顺序的数组组合？而这一问题与原问题不完全一样。

递归式

递归式与分治方法是紧密相关的，因为使用递归式可以很自然地刻画分治算法的运行时间。当问题的规模足够小的时候，直接求解需要常量时间，我们将其写作Θ(1)。假设把原问题分解成a个子问题，每个子问题的规模是原问题的1/b。为了求解一个规模为n/b的子问题，需要T(n/b)的时间，所以需要aT(n/b)的时间来求解a个子问题。如果分解子问题需要时间D(n)，合并子问题的解成原问题的解需要时间C(n)，那么得到递归式：

分治策略求最大子数组问题

对于一个数组A[13 -3 -25 20 -3 -16 -23 18 20 -7 12 -5 22 15 -4 7]，求解其最大子数组，我们很容易地可以设计一个暴力方法来求解本问题，简单地尝试选择每对有可能的下标上限和下标下限，组合成任意子数组，n个数据的数组选择下标的上下限共有n*(n-1)/2 = Θ(n²)种组合，而计算每个子数组的和所需要的时间为常量，则暴力求解方法所花费的时间为 Θ(n²)
思考如何用分治技术来求解最大子数组问题，使用分治技术意味着我们要将子数组划分为两个规模尽量相等的子数组。也就是说找到子数组的中央位置mid，然后考虑求解两个子数组A[low…mid]和A[mid+1…high]。
A[low…high]的任何连续子数组A[i…j]所处的位置必然是以下三种情况之一：

• 完全位于子数组A[low…mid]中。
• 完全位于子数组A[mid+1…high]中。
• 跨越了中点。

而最大的连续子数组的位置也必然是三种情况之一。
用python实现分治策略求解最大子数组问题：

'''
    A: 寻找最大子数组的数组
    low，mid, high: 在分治策略中，利用数组A的下标，进行分组，low代表所分组的下标下限，mid代表所分组的中值
                    high代表所分组的下标的上限。
    作用:分组被mid中值分为左右两半，计算包含mid的最大子数组
'''
def Find_Max_Crossing_Subarray(A, low, mid, high):
    left_sum = -float('inf')
    sum = 0
    for i in range(mid,low-1,-1):
        sum = sum + A[i]
        if sum > left_sum:
            left_sum = sum
            max_left = i
            pass
        pass
    right_sum = -float('inf')
    sum = 0
    for i in range(mid+1, high+1):
        sum = sum + A[i]
        if sum > right_sum:
            right_sum = sum
            max_right = i
            pass
        pass
    return (max_left, max_right, left_sum+right_sum)
    pass

# 分治策略的主体，实现递归求解最大子数组
def Find_Maximum_Subarray(A, low, high):
    if high == low :
        return (low, high, A[low])
    else:
        # mid 将数组分为左右两个部分
        mid = int((low + high)/2)
        # 计算左部分的最大子数组
        (left_low, left_high, left_sum) = Find_Maximum_Subarray(A, low, mid)
        # 计算右部分的最大子数组
        (right_low, right_high, right_sum) = Find_Maximum_Subarray(A, mid+1, high)
        # 计算跨越了中点的最大子数组
        (cross_low, cross_high, cross_sum) = Find_Max_Crossing_Subarray(A, low, mid, high)
        if left_sum > right_sum and left_sum > cross_sum :
            return (left_low, left_high, left_sum)
        elif right_sum > left_sum and right_sum > cross_sum:
            return (right_low, right_high, right_sum)
        else :
            return (cross_low, cross_high, cross_sum)
    pass

if __name__ == '__main__':
    A = [13,-3,-25,20,-3,-16,-23,18,20,-7,12,-5,-22,15,-4,7]
    print(len(A))
    print(Find_Maximum_Subarray(A,0,15))
    print(18+20-7+12)

分治算法的分析

该求解最大子数组问题的分治算法，我们针对算法的主体Find_Maximum_Subarray进行分析，当n=1时，花费的时间为常量时间，记为T(1) = Θ(1)
而当n>1时，我们将原问题分解为两个规模为n/2的子问题，因此每个子问题的求解时间为T(n/2)，而调用Find_Max_Crossing_Subarray所需要的时间为Θ(n)，Θ(n)包含一些需要常量时间的步骤，则可以得到递归式：

此递归式与归并排序递归式相似，可以求解得到T(n) = Θ(n*lgn）