算法学习_python-7

最大子序列：

#! /usr/bin/env python
#coding=utf-8

def find_crossing_subarray（A,low,mid,high):
    left_sum = float("-inf")
    sum  = 0
    max_left = 0
    max_right = 0
    for i in range(mid,low-1,-1):
        sum = sum + A[i]
        if sum > lef_sum:
            left_sum = sum
            max_left = i
    sum = 0
    for j in range(mid+1,high+1,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]

if __name__ == '__main__':
    a=[-1,2,3,-4]
    max = find_maximum_subarray(a, 0, len(a)-1)
    print (max)
输出[1, 2, 5]
时间复杂度为nlgn，a[1]+a[2] = 5
当A[1,2，...n]为最大子序列，判断A[1，2,...n，n+1]的最大子序列：

#! /usr/bin/ python
#coding=utf-8

def j_subarry(A):
    
    M = 0
    M_high = len(A)-1
    for j in range(0,len(A)-1):
        M = M + A[j]
        print(M)
    print(A[len(A)-1])
    if M+A[len(A)-1] > M:
        M = M + A[len(A)-1]
        M_high = M_high + 1
    else:
        M = M
        M_high = M_high
    return (M_high,M)
a = j_subarry([1,4,-2])
print(a)

 时间复杂度为n   
(2, 5)