分治策略

一.在分治策略中，递归地求解一个问题，在每层递归中应用如下三个步骤：

二.分治法分析归并排序

（1）把原数组分成两部分进行处理

（2）递归求解这两部分

（3）把求解好的两部分合并起来

三.二分查找:在数组中查找x的位置

（1）分：把x和已排序好数组的中间值进行比较

（2）治：在子数组中递归

（3）合并：Nothing 

T（n）=T（n/2）+θ（1）

=θ（lgn）

四.乘方问题：给定x,和n,要求计算xⁿ

（1）分：n/2(n偶数)或(n-1)/2（n奇数）

（2）治：x^n/2或者x^(n-1)/2

（3）合并：nothing或*x

T（n）=T（n/2）+θ（1）

=θ（lgn）

五.矩阵乘法

斐波那契数：F（n）=F(n-1）+F（n-2）其中(n>=2)

（1）一般矩阵乘法

#矩阵乘法 O(n*3)
def square_matrix_multiply(A,B):
    C = []
    n = len(A)#A的阶
    C = [[0 for col in range(n)] for row in range(n)]#生成n*n的全0矩阵
    for i in range(0,n):
        for j in range(0,n):
            for k in range(0,n):
                C[i][j]=C[i][j]+A[i][k]*B[k][j]#矩阵乘法规则
    return C
A=[[1,3],[7,5]]
B=[[6,8],[4,2]]
print(square_matrix_multiply(A, B))
--------------------------------------------
[[18, 14], [62, 66]]

（2）简单的递归分治

#递归分治法-矩阵乘法
def square_matrix_multiply_recursive(A, B):
    n = len(A)
    C = [[0 for col in range(n)] for row in range(n)]
    if n == 1:
        C[0][0] = A[0][0] * B[0][0]
    else:
        (A11, A12, A21, A22) = partition_matrix(A)
        (B11, B12, B21, B22) = partition_matrix(B)
        (C11, C12, C21, C22) = partition_matrix(C)
        C11 = add_matrix(square_matrix_multiply_recursive(A11, B11), square_matrix_multiply_recursive(A12, B21))
        C12 = add_matrix(square_matrix_multiply_recursive(A11, B12), square_matrix_multiply_recursive(A12, B22))
        C21 = add_matrix(square_matrix_multiply_recursive(A21, B11), square_matrix_multiply_recursive(A22, B21))
        C22 = add_matrix(square_matrix_multiply_recursive(A21, B12), square_matrix_multiply_recursive(A22, B22))
        C = merge_matrix(C11, C12, C21, C22)
    return C

#分解矩阵，把矩阵分成4分
def partition_matrix(A):
    n = len(A)
    n2 = int(n / 2)
    #生成四个初始零矩阵
    A11 = [[0 for col in range(n2)] for row in range(n2)]
    A12 = [[0 for col in range(n2)] for row in range(n2)]
    A21 = [[0 for col in range(n2)] for row in range(n2)]
    A22 = [[0 for col in range(n2)] for row in range(n2)]
    #给这四个矩阵赋值
    for i in range(0, n2):
        for j in range(0, n2):
            A11[i][j] = A[i][j]
            A12[i][j] = A[i][j + n2]
            A21[i][j] = A[i + n2][j]
            A22[i][j] = A[i + n2][j + n2]
    return (A11, A12, A21, A22)

#合并矩阵，把四个矩阵合并为一个
def merge_matrix(A11, A12, A21, A22):
    n2 = len(A11)
    n = 2 * n2
    A = [[0 for col in range(n)] for row in range(n)]
    for i in range(0, n):
        for j in range(0, n):
            if i <= (n2 - 1) and j <= (n2 - 1):
                A[i][j] = A11[i][j]
            elif i <= (n2 - 1) and j > (n2 - 1):
                A[i][j] = A12[i][j - n2]
            elif i > (n2 - 1) and j <= (n2 - 1):
                A[i][j] = A21[i - n2][j]
            else:
                A[i][j] = A22[i - n2][j - n2]
    return A

#添加矩阵，把A 和 B对应添加进一个矩阵C
def add_matrix(A, B):
    n = len(A)
    C = [[0 for col in range(n)] for row in range(n)]
    for i in range(0, n):
        for j in range(0, n):
            C[i][j] = A[i][j] + B[i][j]
    return C

A=[[1,3],[7,5]]
B=[[6,8],[4,2]]
C=square_matrix_multiply_recursive(A,B)
print(C)
----------------------------------------------------------
[[18, 14], [62, 66]]

（3）Strassen算法 

 

六.最大子数组：寻找A中最大的非空连续子数组

#最大子数组

#求跨越中点的最大子数组
def find_max_crossing_subarray(A, low, mid, high):
    # 先求A[low,mid]的最大子数组，一定是【A[i]，mid】
    left_sum = float("-inf")#目前为止找到的左边的最大和
    sum = 0#A【i..mid 】中所有值的和
    max_left = 0#左边的最大下标
    max_right = 0#右边的最大下标
    for i in range(mid, low - 1, -1):
        sum = sum + A[i]
        if sum > left_sum:
            left_sum = sum
            max_left = i
    #先求A[mid+1，high]的最大子数组,一定是【mid+1，A[j]】
    right_sum = float("-inf")
    sum = 0
    for j in range(mid + 1, high + 1):
        sum = sum + A[j]
        if sum > right_sum:
            right_sum = sum
            max_right = j
    #返回下标和值
    return [max_left, max_right, left_sum + right_sum]

import math

#分治法求解最大子数组，返回子数组的左右下标和总值
def find_maximum_subarray(A, low, high):
    if high == low:
        return (low, high, A[low])
    else:
        mid = math.floor((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]

A=[13,-3,-25,20,-3,-16,-23,18,20,-7,12,-5,-22,15,-4,7]

print(find_maximum_subarray(A, 0, len(A) - 1))
-----------------------------------------------------------------------
[7, 10, 43]

七.完全二叉树的网格布局

规定时间，得到递归式